﻿using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using DynamicAuditor.DTOs;

namespace DynamicAuditor.DALAuditor

{
    /// <summary>
    /// Fecha: 23-Octubre-2010
    /// Autor:Kenneth Bogantes F
    /// Descripcion: En esta clase se va a manejar todas las operaciones correspondientes a SALIDAS A LOS SUB PROCESOS COBIT tales como: Insercion, Actualizacion, Eliminacion
    /// </summary>



   public class clsSubProcesoSalidaMg
    {
        #region conexion

        //Declaracion de la varaiable tipo datacontext que vamos a utilizar en toda la clase.
        DynamicAuditorDataContext bd = new DynamicAuditorDataContext();

        #endregion 

        #region Funciones_Basicas_Mantenimientos

        //--------------------------------------------------------------------------------------------------------------------------

        public int InsertSubProcesoSalida(DTOs.dtoSubProcesoSalida  subProcesoSalida)
        {
            //Se retorna un 1 si el proceso se realizo correctamente de lo contrario se retorna un 0

            int x = 0;
            SUBPROCESOS_SALIDA nuevoRegistro = new SUBPROCESOS_SALIDA();
            
            try
            {

                
                nuevoRegistro.idSubProceso = subProcesoSalida.SubProcesoCobit.IdSubProceso;
                nuevoRegistro.NombreSubProceso = subProcesoSalida.NombreSubSalida;
                nuevoRegistro.Descripcion_Salida = subProcesoSalida.DescripcionSubSalida;
                nuevoRegistro.Activo = subProcesoSalida.Activo;

                //Se procede a insertar la informacion de la Salida del proceso cobit
                bd.SUBPROCESOS_SALIDAs.InsertOnSubmit(nuevoRegistro);
                bd.SubmitChanges();
                x = 1;
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo insertar el registro. " + ex.Message);

            }
            return x;
        }



        //--------------------------------------------------------------------------------------------------------------------------


        public int UpdateSubProcesoSalida(DTOs.dtoSubProcesoSalida subProcesoSalida)
        {
            //Se retorna un 1 si el proceso se realizo correctamente de lo contrario se retorna un 0

            int x = 0;


            try
            {

                SUBPROCESOS_SALIDA registro = bd.SUBPROCESOS_SALIDAs.Single(p => p.idSalida == subProcesoSalida.IdSubProcesoSalida);

                registro.idSalida = subProcesoSalida.IdSubProcesoSalida;
                registro.idSubProceso = subProcesoSalida.SubProcesoCobit.IdSubProceso;
                registro.NombreSubProceso = subProcesoSalida.NombreSubSalida;
                registro.Descripcion_Salida = subProcesoSalida.DescripcionSubSalida;
                registro.Activo = subProcesoSalida.Activo;


                bd.SubmitChanges();
                x = 1;
            }
            catch (Exception ex)
            {
                throw new Exception("Ocurrio un error actualizando el registro. " + ex.Message);
            }
            return x;
        }



        //--------------------------------------------------------------------------------------------------------------------------



        public int DeleteSubProcesoSalida(DTOs.dtoSubProcesoSalida  subProcesoSalida)
        {
            //Se retorna un 1 si el proceso se realizo correctamente de lo contrario se retorna un 0

            int x = 0;

            try
            {

                var registro = bd.SUBPROCESOS_SALIDAs.Single(p => p.idSalida == subProcesoSalida.IdSubProcesoSalida);

                bd.SUBPROCESOS_SALIDAs.DeleteOnSubmit(registro);
                bd.SubmitChanges();
                x = 1;
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo borrar el registro " + ex.Message);
                
            }

            return x;

        }


        //--------------------------------------------------------------------------------------------------------------------------



        public DTOs.dtoSubProcesoSalida  ObtenerSubProcesoSalidaporId(int idSalida)
        {
            DTOs.dtoSubProcesoSalida  registro = new DynamicAuditor.DTOs.dtoSubProcesoSalida ();

            try
            {
                SUBPROCESOS_SALIDA dato = bd.SUBPROCESOS_SALIDAs.Single(p => p.idSalida == idSalida);

                registro.IdSubProcesoSalida = dato.idSalida;
                registro.SubProcesoCobit = new clsSubProcesoCobitMg().ObtenerSubProcesoCobitporId(int.Parse(dato.idSubProceso.ToString()));
                registro.NombreSubSalida = dato.NombreSubProceso;
               
                registro.DescripcionSubSalida = dato.Descripcion_Salida;
                registro.Activo = bool.Parse(dato.Activo.ToString());


            }
            catch (Exception ex)
            {

                throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
                return null;
            }

            return registro;
        }



       






        //--------------------------------------------------------------------------------------------------------------------------



        public List<DTOs.dtoSubProcesoSalida > ObtenerSubProcesosSalidaLista(int idsubproceso)
        {
            int i = 0;
            List<DTOs.dtoSubProcesoSalida > listaDatos = new List<DTOs.dtoSubProcesoSalida >();

            try
            {
                var datos = (from p in bd.SUBPROCESOS_SALIDAs
                             from d in bd.SUBPROCESOS_COBITs
                             where p.idSubProceso == d.idSubProceso && p.idSubProceso == idsubproceso
                             orderby p.idSalida
                             select new { p, d }

                           );

                foreach (var fila in datos)
                {
                    listaDatos.Add(new dtoSubProcesoSalida ());

                    listaDatos[i].IdSubProcesoSalida = fila.p.idSalida;
                    listaDatos[i].SubProcesoCobit = toDTOSubProcesoCobit(fila.d);
                    listaDatos[i].NombreSubSalida = fila.p.NombreSubProceso;
                    listaDatos[i].DescripcionSubSalida = fila.p.Descripcion_Salida;
                    listaDatos[i].Activo = (bool)fila.p.Activo;
                    i++;
                }

            }
            catch (Exception ex)
            {
                throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
            }
            return listaDatos;
        }


        //--------------------------------------------------------------------------------------------------------------------------



        public List<DTOs.dtoSubProcesoSalida > ObtenerSubProcesosSalidaActivosLista(int idsubproceso)
        {
            int i = 0;
            List<DTOs.dtoSubProcesoSalida> listaDatos = new List<DTOs.dtoSubProcesoSalida>();

            try
            {
                var datos = (from p in bd.SUBPROCESOS_SALIDAs
                             from d in bd.SUBPROCESOS_COBITs
                             where p.idSubProceso == d.idSubProceso && p.idSubProceso == idsubproceso
                             && p.Activo == true 
                             orderby p.idSalida
                             select new { p, d }

                           );

                foreach (var fila in datos)
                {
                    listaDatos.Add(new dtoSubProcesoSalida());

                    listaDatos[i].IdSubProcesoSalida = fila.p.idSalida;
                    listaDatos[i].SubProcesoCobit = toDTOSubProcesoCobit(fila.d);
                    listaDatos[i].NombreSubSalida = fila.p.NombreSubProceso;
                    listaDatos[i].DescripcionSubSalida = fila.p.Descripcion_Salida;
                    listaDatos[i].Activo = (bool)fila.p.Activo;
                    i++;
                }

            }
            catch (Exception ex)
            {
                throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
            }
            return listaDatos;
        }


        //--------------------------------------------------------------------------------------------------------------------------



        private dtoSubProcesoCobit toDTOSubProcesoCobit(SUBPROCESOS_COBIT subprocesoCobit)
        {
            dtoSubProcesoCobit nuevo = new dtoSubProcesoCobit();
            nuevo.IdSubProceso = subprocesoCobit.idSubProceso;
            nuevo.ProcesoCobit = new clsProcesoCobitMg().ObtenerProcesoCobitporId((int)subprocesoCobit.idProceso);
            nuevo.SiglasSubProceso = subprocesoCobit.SiglaSubProceso;
            nuevo.NombreSubProceso = subprocesoCobit.NombreSubProceso;
            nuevo.Descripcion = subprocesoCobit.Descripcion;
            nuevo.Activo = (bool)subprocesoCobit.Activo;
            return nuevo;
        }

        #endregion






    }
}
